// 导入依赖资源


const linli = uniCloud.importObject('linliChat')
import store from '../store';
/**
 * 收藏功能处理类
 * 负责收藏的添加、删除、修改配置等操作
 */
export default class Favorite {
	// 网格计算结果缓存（避免重复计算）
	#gridCache = new Map();

	/**
	 * 构造函数
	 * @param {Object} location - 地理位置对象 {longitude, latitude}
	 * @param {number} defaultRadius - 默认半径（可选，默认5）
	 * 	 * @param {Object} storeData - 组件传递的 storeData（包含 user）
	 */
	constructor(location, storeData, defaultRadius = 5, ) {
		// 基础属性初始化
		this.user = storeData.user
		this.storeData = storeData
		this.location = location;
		this.config = {
			sound: 1, // 0:无声, 1:声音, 2:振动
			radius: defaultRadius, // 修复未定义的radius
			tip: 0 // 提醒配置
		};

		// 数据对象初始化
		this.data = {
			action: "",
			userId: this.user?.userId || '', // 容错处理：用户未登录场景
			type: "favorite",
			name: this.storeData.address.addressShort || '收藏点', // 临时默认名，将在initAddress中更新
			location: this.location,
			address: this.storeData.address.address || '无名地址', // 临时默认地址，将在initAddress中更新
			favorite_id: this.#getGridCode(location), // 生成唯一标识
			config: this.config
		};

	}



	/**
	 * 添加收藏
	 * @param {string} [name] - 可选名称（如不提供则使用地址短名）
	 * @returns {Promise<Object>} 操作结果 {code, data, msg}
	 */
	async add(location, name) {
		try {
			// 参数校验


			if (!this.data.userId) {
				return {
					code: false,
					msg: '用户未登录'
				};
			}
			if (typeof location !== 'object' && Object.keys(location).length === 0) {
				return {
					code: false,
					msg: '没有位置信息'
				}
			}
			// 更新名称（如提供）
			if (name && typeof name === 'string') {
				this.data.name = name;
				this.data.location = location
			}
			console.log('地址。。。。。', this.data);
			// 准备请求数据
			const requestData = {
				...this.data,
				action: 'add',
				type: 'location',
				config: this.config,
				location: location,

			};

			// 调用云函数
			const res = await linli.favorite(requestData);


			return res

		} catch (e) {
			console.error('添加收藏失败：', e);
			return {
				code: false,
				msg: '添加收藏失败'
			};
		}
	}

	/**
	 * 移除收藏
	 * @param {string} 收藏Id 
	 * @returns {Promise<Object>} 操作结果 {code, data, msg,新的收藏列表数组favorite }
	 */
	async remove(id) {
		console.log(id);
		try {
			// 参数校验
			if (!this.data.userId) {
				return {
					code: false,
					msg: '用户未登录'
				};
			}

			// 准备请求数据
			const requestData = {
				...this.data,
				favorite_id: id,
				action: 'remove'
			};

			// 调用云函数
			const res = await linli.favorite(requestData);

			if (res.code) {

				store.commit('msg/SET_user', {
					...this.user,
					favorite: res.data.favorite
				});
				return {
					code: true,
					data: res
				};

			} else {
				return {
					code: false,
					msg: res.msg
				};
			}

		} catch (e) {
			console.error('移除收藏失败：', e);
			return {
				code: false,
				msg: '移除收藏失败'
			};
		}
	}

	/**
	 * 检查当前位置是否已被收藏
	 * @returns {Object} 检查结果 {code: boolean, favorite?: Object}
	 */
	isFavorited(location) {
		try {
			const user = this.storeData.user;
			if (!user?.favorite || !user.favorite.length) {
				return {
					code: false
				};
			}

			// 计算当前位置的网格编码
			const currentGrid = this.#getGridCode(location);

			// 遍历用户收藏列表检查
			for (const favoriteItem of user.favorite) {
				// 计算收藏项的周边网格
				const surroundingGrids = this.#getSurroundingGrids(
					favoriteItem.favorite_id,
					favoriteItem.config?.radius || 5
				);
				// 检查当前网格是否在周边范围内（修复includes使用错误）
				const isInRange = surroundingGrids.some(grid => grid === currentGrid);
				if (isInRange) {
					return {
						code: true,
						favorite: favoriteItem
					};
				}
			}

			return {
				code: false
			};
		} catch (e) {
			console.error('检查收藏状态失败：', e);
			return {
				code: false
			};
		}
	}

	/**
	 * 重命名收藏
	 * @param {string} id - 收藏ID
	 * @param {string} name - 新名称
	 * @returns {Promise<Object>} 操作结果 {code, msg}
	 */
	async rename(id, name) {
		return this.#updateFavorite(
			id,
			name,
			(item) => ({
				...item,
				name
			})
		);
	}

	/**
	 * 设置收藏半径
	 * @param {string} id - 收藏ID
	 * @param {number} radius - 新半径
	 * @returns {Promise<Object>} 操作结果 {code, msg}
	 */
	async setRadius(id, radius) {
		// 半径参数校验
		if (typeof radius !== 'number' || radius < 0) {
			return {
				code: false,
				msg: '半径必须是非负数字'
			};
		}
		return this.#updateFavorite(
			id,
			radius,
			(item) => ({
				...item,
				config: {
					...item.config,
					radius
				}
			})
		);
	}

	/**
	 * 设置收藏提醒方式
	 * @param {string} id - 收藏ID
	 * @param {number} tip - 提醒配置（0:关闭, 1:开启）
	 * @returns {Promise<Object>} 操作结果 {code, msg}
	 */
	async setTip(id, tip) {
		if (![0, 1].includes(tip)) {
			return {
				code: false,
				msg: '提醒配置值必须为0或1'
			};
		}
		return this.#updateFavorite(
			id,
			tip,
			(item) => ({
				...item,
				config: {
					...item.config,
					tip
				}
			})
		);
	}

	/**
	 * 设置收藏声音提醒
	 * @param {string} id - 收藏ID
	 * @param {number} sound - 声音配置（0:无声, 1:声音, 2:振动）
	 * @returns {Promise<Object>} 操作结果 {code, msg}
	 */
	async setSound(id, sound) {
		console.log(id, sound);
		if (![0, 1, 2].includes(sound)) {
			return {
				code: false,
				msg: '声音配置值必须为0、1或2'
			};
		}
		return this.#updateFavorite(
			id,
			sound,
			(item) => ({
				...item,
				config: {
					...item.config,
					sound
				}
			})
		);
	}

	/**
	 * 通用收藏更新方法（封装重复逻辑）
	 * @param {string} id - 收藏ID
	 * @param {*} value - 要更新的值
	 * @param {Function} updateFn - 更新逻辑函数
	 * @returns {Promise<Object>} 操作结果
	 */
	async #updateFavorite(id, value, updateFn) {
		try {
			// 基础校验
			const user = this.storeData.user;
			if (!user?.userId) {
				return {
					code: false,
					msg: '用户未登录'
				};
			}
			if (!id || typeof id !== 'string') {
				return {
					code: false,
					msg: '收藏ID格式错误'
				};
			}

			// 获取当前收藏列表
			const oldFavorites = user.favorite || [];
			const targetIndex = oldFavorites.findIndex(item => item.favorite_id === id);
			if (targetIndex === -1) {
				return {
					code: false,
					msg: '未找到该收藏'
				};
			}

			// 生成新的收藏列表
			const newFavorites = oldFavorites.map(item =>
				item.favorite_id === id ? updateFn(item) : item
			);
			store.commit('msg/SET_user', {
				...user,
				favorite: newFavorites
			});
			const userId = user.userId
			const res = await linli.updataUser(userId, {
				favorite: newFavorites
			})
			console.log("更新成功", res);
			if (res.code) {
				return {
					code: true,
					msg: '更新成功'
				};
			} else {
				return {
					code: false,
					msg: '操作异常，请重试'
				};
			}


		} catch (e) {
			console.error('更新收藏配置失败：', e);
			return {
				code: false,
				msg: '操作异常，请重试'
			};
		}
	}



	/**
	 * 计算周边网格（私有方法）
	 * @param {string} centerGrid - 中心网格编码
	 * @param {number} radius - 半径
	 * @returns {Array<string>} 周边网格编码列表
	 */
	#getSurroundingGrids(centerGrid, radius) {
		// 检查缓存
		const cacheKey = `${centerGrid}_${radius}`;
		if (this.#gridCache.has(cacheKey)) {
			return this.#gridCache.get(cacheKey);
		}

		try {
			// 解析中心网格的经纬度
			const [lonStr, latStr] = centerGrid.split('_');
			if (!lonStr || !latStr) {
				throw new Error('无效的网格编码');
			}
			let centerLon = parseFloat(lonStr);
			let centerLat = parseFloat(latStr);

			// 边界校验
			if (isNaN(centerLon) || isNaN(centerLat)) {
				throw new Error('网格编码解析失败');
			}

			const grids = new Set();
			// 计算半径范围内的所有网格
			for (let x = -radius; x <= radius; x++) {
				for (let y = -radius; y <= radius; y++) {
					// 计算目标经纬度（步长0.001度）
					let targetLon = centerLon + x * 0.001;
					let targetLat = centerLat + y * 0.001;

					// 处理经度环绕（-180 ~ 180）
					if (targetLon < -180) targetLon += 360;
					else if (targetLon > 180) targetLon -= 360;

					// 处理纬度边界（-90 ~ 90）
					targetLat = Math.max(-90, Math.min(90, targetLat));

					// 生成网格编码并添加到集合（去重）
					grids.add(this.#getGridCode({
						longitude: targetLon,
						latitude: targetLat
					}));
				}
			}

			const result = Array.from(grids);
			// 缓存结果
			this.#gridCache.set(cacheKey, result);
			return result;
		} catch (e) {
			console.error('计算周边网格失败：', e);
			return [];
		}
	}

	/**
	 * 生成网格编码（私有方法）
	 * @param {Object} location - 地理位置 {longitude, latitude}
	 * @returns {string} 网格编码（格式：经度_纬度，保留3位小数）
	 */
	#getGridCode(location) {
		try {
			if (!location?.longitude || !location?.latitude) {
				throw new Error('无效的地理位置');
			}
			// 四舍五入保留3位小数
			const lonPart = (Math.round(location.longitude * 1000) / 1000).toFixed(3);
			const latPart = (Math.round(location.latitude * 1000) / 1000).toFixed(3);
			return `${lonPart}_${latPart}`;
		} catch (e) {
			console.error('生成网格编码失败：', e);
			return 'invalid_grid';
		}
	}
}